home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Toolbox / Visual Basic Toolbox (P.I.E.)(1996).ISO / internet / pwrtcp / tntcpp.cp_ / tntcpp.bin
Encoding:
Text File  |  1995-05-18  |  34.2 KB  |  1,200 lines
  1. //---------------------------------------------------------------------------
  2. //
  3. //  Module: tty.c
  4. //
  5. //  Purpose:
  6. //     The sample application demonstrates the usage of the COMM
  7. //     API.  It implements the new COMM API of Windows 3.1.
  8. //
  9. //     NOTE:  no escape sequences are translated, only
  10. //            the necessary control codes (LF, CR, BS, etc.)
  11. //
  12. //  Description of functions:
  13. //     Descriptions are contained in the function headers.
  14. //
  15. //---------------------------------------------------------------------------
  16. //
  17. //  Written by Microsoft Product Support Services, Windows Developer Support.
  18. //  Copyright (c) 1991 Microsoft Corporation.  All Rights Reserved.
  19. //
  20. //---------------------------------------------------------------------------
  21.  
  22. //***************************************************************************
  23. //
  24. //  Module: tntcpp.cpp
  25. //
  26. //  Purpose:
  27. //     The sample application demonstrates the usage of the PowerTCP
  28. //     API.  It uses the new PowerTCP DLL interface. Compiled under Windows 3.1
  29. //     and Windows NT 3.5 Beta
  30. //
  31. //     NOTE: This code was derived from Microsoft's tty.h
  32. //             
  33. //***************************************************************************
  34. //
  35. //  Written by Dart Communication Application Programming Group.
  36. //  Copyright (c) 1994 Dart Communications.  All Rights Reserved.
  37. //
  38. //***************************************************************************
  39.  
  40. #define STRICT       // be bold!
  41. #pragma warning (disable:4100 4355 4699)
  42.  
  43. #include <windows.h>
  44. #include <commdlg.h>
  45. #include <string.h>
  46. #include <malloc.h>
  47.  
  48. #include "version.h"
  49. #include "tntc.hh"
  50. #include "..\..\include\powertcp.h"
  51. #include "..\..\include\powertcp.hpp" // for CPowerTcp class def
  52. #include "..\..\include\powertnt.hpp" // for CPowerTelnet class def
  53. #include "tntsampl.hpp" // for our Derived Class
  54. #include "tntsamp.h"
  55.  
  56. char           szHost[20]="" ;
  57. char              szPort[5]="23" ;          
  58. WORD            Port;
  59. BOOL            TransOk;
  60. HINSTANCE    hInstance=NULL;
  61. PTTYINFO TTYInfo=NULL;
  62.  
  63. CMyPowerTelnet *MyPowerTelnet=NULL;
  64.  
  65. //---------------------------------------------------------------------------
  66. //  int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
  67. //                      LPSTR lpszCmdLine, int nCmdShow )
  68. //
  69. //  Description:
  70. //     This is the main window loop!
  71. //
  72. //  Parameters:
  73. //     As documented for all WinMain() functions.
  74. //
  75. //---------------------------------------------------------------------------
  76.  
  77. int PASCAL WinMain( HINSTANCE hNewInstance, HINSTANCE hPrevInstance,
  78.                     LPSTR lpszCmdLine, int nCmdShow )
  79. {
  80.    HWND  hTTYWnd ;
  81.    MSG   msg ;
  82.  
  83.    hInstance=hNewInstance;
  84.  
  85.    if (!hPrevInstance)
  86.       if (!InitApplication( hInstance ))
  87.          return ( FALSE ) ;
  88.  
  89.    if (NULL == (hTTYWnd = InitInstance( hInstance, nCmdShow )))
  90.       return ( FALSE ) ;
  91.  
  92.    while (GetMessage( &msg, NULL, 0, 0 ))
  93.    {
  94.       if (!TranslateAccelerator( hTTYWnd, ghAccel, &msg ))
  95.       {
  96.          TranslateMessage( &msg ) ;
  97.          DispatchMessage( &msg ) ;
  98.       }
  99.    }
  100.    return ( (int) msg.wParam ) ;
  101.  
  102. } // end of WinMain()
  103.  
  104. //---------------------------------------------------------------------------
  105. //  BOOL InitApplication( HANDLE hInstance )
  106. //
  107. //  Description:
  108. //     First time initialization stuff.  This registers information
  109. //     such as window classes.
  110. //
  111. //  Parameters:
  112. //     HANDLE hInstance
  113. //        Handle to this instance of the application.
  114. //
  115. //---------------------------------------------------------------------------
  116.  
  117. BOOL InitApplication( HINSTANCE hInstance )
  118. {
  119.    WNDCLASS  wndclass ;
  120.  
  121.    // register tty window class
  122.  
  123.    wndclass.style =         0 ;
  124.    wndclass.lpfnWndProc =   TTYWndProc ;
  125.    wndclass.cbClsExtra =    0 ;
  126.    wndclass.cbWndExtra =    0;
  127.    wndclass.hInstance =     hInstance ;
  128.    wndclass.hIcon =         LoadIcon( hInstance, "PowerTNT" );
  129.    wndclass.hCursor =       LoadCursor( NULL, IDC_ARROW ) ;
  130.    wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  131.    wndclass.lpszMenuName =  MAKEINTRESOURCE( TTYMENU ) ;
  132.    wndclass.lpszClassName = gszTTYClass ;
  133.  
  134.    return( RegisterClass( &wndclass ) ) ;
  135.  
  136. } // end of InitApplication()
  137.  
  138. //---------------------------------------------------------------------------
  139. //  HWND InitInstance( HANDLE hInstance, int nCmdShow )
  140. //
  141. //  Description:
  142. //     Initializes instance specific information.
  143. //
  144. //  Parameters:
  145. //     HANDLE hInstance
  146. //        Handle to instance
  147. //
  148. //     int nCmdShow
  149. //        How do we show the window?
  150. //
  151. //---------------------------------------------------------------------------
  152.  
  153. HWND InitInstance( HINSTANCE hInstance, int nCmdShow )
  154. {
  155.    HWND  hTTYWnd ;
  156.  
  157.    // load accelerators
  158.    ghAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE( TTYACCEL ) ) ;
  159.  
  160.    // create the TTY window
  161.    hTTYWnd = CreateWindow( gszTTYClass, gszAppName,
  162.                            WS_OVERLAPPEDWINDOW,
  163.                            CW_USEDEFAULT, CW_USEDEFAULT,
  164.                            CW_USEDEFAULT, CW_USEDEFAULT,
  165.                            NULL, NULL, hInstance, NULL ) ;
  166.  
  167.    if (NULL == hTTYWnd)
  168.       return ( NULL ) ;
  169.    
  170.    ShowWindow( hTTYWnd, nCmdShow ) ;
  171.    UpdateWindow( hTTYWnd ) ;
  172.    SetWindowText(hTTYWnd, " PowerTCP TELNET Demo ");
  173.    OpenConnection(hTTYWnd);
  174.  
  175.    return ( hTTYWnd ) ;
  176.  
  177. } // end of InitInstance()
  178.  
  179. //---------------------------------------------------------------------------
  180. //  LRESULT FAR PASCAL __export TTYWndProc( HWND hWnd, UINT uMsg,
  181. //                                 WPARAM wParam, LPARAM lParam )
  182. //
  183. //  Description:
  184. //     This is the TTY Window Proc.  This handles ALL messages
  185. //     to the tty window.
  186. //
  187. //  Parameters:
  188. //     As documented for Window procedures.
  189. //
  190. //---------------------------------------------------------------------------
  191.  
  192. LRESULT CALLBACK TTYWndProc( HWND hWnd, UINT uMsg,
  193.                                WPARAM wParam, LPARAM lParam )
  194. {
  195.    switch (uMsg)
  196.    {
  197.       case WM_CREATE:
  198.          return ( CreateTTYInfo( hWnd ) ) ;
  199.  
  200.       case WM_COMMAND:
  201.       {
  202.          switch ((WORD) wParam)
  203.          {
  204.             case IDM_CONNECT:
  205.                if (!OpenConnection( hWnd ))
  206.                   MessageBox( hWnd, "Connection failed.", gszAppName,
  207.                               MB_ICONEXCLAMATION ) ;
  208.                break ;
  209.  
  210.             case IDM_DISCONNECT:
  211.                CloseConnection( hWnd ) ;
  212.                int i;
  213.                i=5;
  214.                break ;
  215.  
  216.             case IDM_ABOUT:
  217.                GoModalDialogBoxParam ( hInstance,
  218.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  219.                                        hWnd,
  220.                                        AboutDlgProc, 0l ) ;
  221.                break;
  222.  
  223.             case IDM_EXIT:
  224.                PostMessage( hWnd, WM_CLOSE, 0, 0L ) ;
  225.                break ;
  226.          }
  227.       }
  228.       break ;
  229.  
  230.       case WM_PAINT:
  231.          PaintTTY( hWnd ) ;
  232.          break ;
  233.  
  234.       case WM_SIZE:
  235.          SizeTTY( hWnd, HIWORD( lParam ), LOWORD( lParam ) ) ;
  236.          break ;
  237.  
  238.       case WM_HSCROLL:
  239.          ScrollTTYHorz( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  240.          break ;
  241.  
  242.       case WM_VSCROLL:
  243.          ScrollTTYVert( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  244.          break ;
  245.  
  246.       case WM_CHAR:
  247.          ProcessTTYCharacter( hWnd, LOBYTE( wParam ) ) ;
  248.          break ;
  249.  
  250.       case WM_SETFOCUS:
  251.          SetTTYFocus( hWnd ) ;
  252.          break ;
  253.  
  254.       case WM_KILLFOCUS:
  255.          KillTTYFocus( hWnd ) ;
  256.          break ;
  257.  
  258.       case WM_DESTROY:
  259.          DestroyTTYInfo( hWnd ) ;
  260.          PostQuitMessage( 0 ) ;
  261.          break ;
  262.  
  263.       case WM_CLOSE:
  264.          if (MyPowerTelnet)
  265.              MyPowerTelnet->Close(TRUE);  // abort
  266.          GoModalDialogBoxParam ( hInstance,
  267.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  268.                                        hWnd,
  269.                                        AboutDlgProc, 0l ) ;
  270.          // fall through
  271.  
  272.       default:
  273.          return( DefWindowProc( hWnd, uMsg, wParam, lParam ) ) ;
  274.    }
  275.    return 0L ;
  276.  
  277. } // end of TTYWndProc()
  278.  
  279. //---------------------------------------------------------------------------
  280. //  LRESULT CreateTTYInfo( HWND hWnd )
  281. //
  282. //  Description:
  283. //     Creates the tty information structure and sets
  284. //     menu option availability.  Returns -1 if unsuccessful.
  285. //
  286. //  Parameters:
  287. //     HWND  hWnd
  288. //        Handle to main window.
  289. //
  290. //---------------------------------------------------------------------------
  291.  
  292. LRESULT CreateTTYInfo( HWND hWnd )
  293. {
  294.    HMENU       hMenu ;
  295.  
  296.    if (NULL == (TTYInfo =
  297.                    (PTTYINFO) malloc( sizeof( TTYINFO ) )))
  298.       return ( (LRESULT) -1 ) ;
  299.  
  300.    // initialize TTY info structure
  301.    memset (TTYInfo,0,sizeof(TTYINFO));
  302.  
  303.    COMDEV( TTYInfo )        = 0 ;
  304.    CONNECTED( TTYInfo )     = FALSE ;
  305.    CURSORSTATE( TTYInfo )   = CS_HIDE ;
  306.    LOCALECHO( TTYInfo )     = FALSE ;
  307.    AUTOWRAP( TTYInfo )      = TRUE ;
  308.  
  309.    // clear screen space
  310.    memset( SCREEN( TTYInfo ), ' ', MAXROWS * MAXCOLS ) ;
  311.  
  312.    // setup default font information
  313.  
  314.    LFTTYFONT( TTYInfo ).lfHeight =         12 ;
  315.    LFTTYFONT( TTYInfo ).lfWidth =          0 ;
  316.    LFTTYFONT( TTYInfo ).lfEscapement =     0 ;
  317.    LFTTYFONT( TTYInfo ).lfOrientation =    0 ;
  318.    LFTTYFONT( TTYInfo ).lfWeight =         0 ;
  319.    LFTTYFONT( TTYInfo ).lfItalic =         0 ;
  320.    LFTTYFONT( TTYInfo ).lfUnderline =      0 ;
  321.    LFTTYFONT( TTYInfo ).lfStrikeOut =      0 ;
  322.    LFTTYFONT( TTYInfo ).lfCharSet =        OEM_CHARSET ;
  323.    LFTTYFONT( TTYInfo ).lfOutPrecision =   OUT_DEFAULT_PRECIS ;
  324.    LFTTYFONT( TTYInfo ).lfClipPrecision =  CLIP_DEFAULT_PRECIS ;
  325.    LFTTYFONT( TTYInfo ).lfQuality =        DEFAULT_QUALITY ;
  326.    LFTTYFONT( TTYInfo ).lfPitchAndFamily = FIXED_PITCH | FF_MODERN ;
  327.    LFTTYFONT( TTYInfo ).lfFaceName[0] =    0 ;
  328.  
  329.    // reset the character information, etc.
  330.  
  331.    ResetTTYScreen( hWnd ) ;
  332.  
  333.    hMenu = GetMenu( hWnd ) ;
  334.    EnableMenuItem( hMenu, IDM_DISCONNECT,
  335.                    MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
  336.    EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  337.  
  338.    return ( (LRESULT) TRUE ) ;
  339.  
  340. } // end of CreateTTYInfo()
  341.  
  342. //---------------------------------------------------------------------------
  343. //  BOOL DestroyTTYInfo( HWND hWnd )
  344. //
  345. //  Description:
  346. //     Destroys block associated with TTY window handle.
  347. //
  348. //  Parameters:
  349. //     HWND hWnd
  350. //        handle to TTY window
  351. //
  352. //---------------------------------------------------------------------------
  353.  
  354. BOOL DestroyTTYInfo( HWND hWnd )
  355. {
  356.  
  357.    if (!TTYInfo)
  358.       return ( FALSE ) ;
  359.  
  360.    // force connection closed (if not already closed)
  361.  
  362.    if (CONNECTED( TTYInfo ))
  363.       CloseConnection( hWnd ) ;
  364.  
  365.    DeleteObject( HTTYFONT( TTYInfo ) ) ;
  366.  
  367.    free ( TTYInfo ) ;
  368.    return ( TRUE ) ;
  369.  
  370. } // end of DestroyTTYInfo()
  371.  
  372. //---------------------------------------------------------------------------
  373. //  BOOL ResetTTYScreen( HWND hWnd, TTYINFO TTYInfo )
  374. //
  375. //  Description:
  376. //     Resets the TTY character information and causes the
  377. //     screen to resize to update the scroll information.
  378. //
  379. //  Parameters:
  380. //     TTYINFO  TTYInfo
  381. //        pointer to TTY info structure
  382. //
  383. //---------------------------------------------------------------------------
  384.  
  385. BOOL ResetTTYScreen( HWND hWnd)
  386. {
  387.    HDC         hDC ;
  388.    TEXTMETRIC  tm ;
  389.    RECT        rcWindow ;
  390.  
  391.    if (NULL == TTYInfo)
  392.       return ( FALSE ) ;
  393.  
  394.    if (NULL != HTTYFONT( TTYInfo ))
  395.       DeleteObject( HTTYFONT( TTYInfo ) ) ;
  396.  
  397.    HTTYFONT( TTYInfo ) = CreateFontIndirect( &LFTTYFONT( TTYInfo ) ) ;
  398.  
  399.    hDC = GetDC( hWnd ) ;
  400.    SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  401.    GetTextMetrics( hDC, &tm ) ;
  402.    ReleaseDC( hWnd, hDC ) ;
  403.  
  404.    XCHAR( TTYInfo ) = tm.tmAveCharWidth  ;
  405.    YCHAR( TTYInfo ) = tm.tmHeight + tm.tmExternalLeading ;
  406.  
  407.    // a slimy hack to force the scroll position, region to
  408.    // be recalculated based on the new character sizes
  409.  
  410.    GetWindowRect( hWnd, &rcWindow ) ;
  411.    SendMessage( hWnd, WM_SIZE, SIZENORMAL,
  412.                 (LPARAM) MAKELONG( rcWindow.right - rcWindow.left,
  413.                                    rcWindow.bottom - rcWindow.top ) ) ;
  414.  
  415.    return ( TRUE ) ;
  416.  
  417. } // end of ResetTTYScreen()
  418.  
  419. //---------------------------------------------------------------------------
  420. //  BOOL PaintTTY( HWND hWnd )
  421. //
  422. //  Description:
  423. //     Paints the rectangle determined by the paint struct of
  424. //     the DC.
  425. //
  426. //  Parameters:
  427. //     HWND hWnd
  428. //        handle to TTY window (as always)
  429. //
  430. //---------------------------------------------------------------------------
  431.  
  432. BOOL PaintTTY( HWND hWnd )
  433. {
  434.    int          nRow, nCol, nEndRow, nEndCol, nCount, nHorzPos, nVertPos ;
  435.    HDC          hDC ;
  436.    HGDIOBJ      hOldFont ;
  437.    PAINTSTRUCT  ps ;
  438.    RECT         rect ;
  439.  
  440.    if (NULL == TTYInfo)
  441.       return ( FALSE ) ;
  442.  
  443.    hDC = BeginPaint( hWnd, &ps ) ;
  444.    hOldFont = SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  445.    SetTextColor( hDC, FGCOLOR( TTYInfo ) ) ;
  446.    SetBkColor( hDC, GetSysColor( COLOR_WINDOW ) ) ;
  447.    rect = ps.rcPaint ;
  448.    nRow =
  449.       min( MAXROWS - 1,
  450.            max( 0, (rect.top + YOFFSET( TTYInfo )) / YCHAR( TTYInfo ) ) ) ;
  451.    nEndRow =
  452.       min( MAXROWS - 1,
  453.            ((rect.bottom + YOFFSET( TTYInfo ) - 1) / YCHAR( TTYInfo ) ) ) ;
  454.    nCol =
  455.       min( MAXCOLS - 1,
  456.            max( 0, (rect.left + XOFFSET( TTYInfo )) / XCHAR( TTYInfo ) ) ) ;
  457.    nEndCol =
  458.       min( MAXCOLS - 1,
  459.            ((rect.right + XOFFSET( TTYInfo ) - 1) / XCHAR( TTYInfo ) ) ) ;
  460.    nCount = nEndCol - nCol + 1 ;
  461.    for (; nRow <= nEndRow; nRow++)
  462.    {
  463.       nVertPos = (nRow * YCHAR( TTYInfo )) - YOFFSET( TTYInfo ) ;
  464.       nHorzPos = (nCol * XCHAR( TTYInfo )) - XOFFSET( TTYInfo ) ;
  465.       rect.top = nVertPos ;
  466.       rect.bottom = nVertPos + YCHAR( TTYInfo ) ;
  467.       rect.left = nHorzPos ;
  468.       rect.right = nHorzPos + XCHAR( TTYInfo ) * nCount ;
  469.       SetBkMode( hDC, OPAQUE ) ;
  470.       ExtTextOut( hDC, nHorzPos, nVertPos, ETO_OPAQUE | ETO_CLIPPED, &rect,
  471.                   (LPSTR)( SCREEN( TTYInfo ) + nRow * MAXCOLS + nCol ),
  472.                   nCount, NULL ) ;
  473.    }
  474.    SelectObject( hDC, hOldFont ) ;
  475.    EndPaint( hWnd, &ps ) ;
  476.    MoveTTYCursor( hWnd ) ;
  477.    return ( TRUE ) ;
  478.  
  479. } // end of PaintTTY()
  480.  
  481. //---------------------------------------------------------------------------
  482. //  BOOL SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  483. //
  484. //  Description:
  485. //     Sizes TTY and sets up scrolling regions.
  486. //
  487. //  Parameters:
  488. //     HWND hWnd
  489. //        handle to TTY window
  490. //
  491. //     WORD wVertSize
  492. //        new vertical size
  493. //
  494. //     WORD wHorzSize
  495. //        new horizontal size
  496. //
  497. //---------------------------------------------------------------------------
  498.  
  499. BOOL SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  500. {
  501.    int        nScrollAmt ;
  502.  
  503.    if (NULL == TTYInfo)
  504.       return ( FALSE ) ;
  505.  
  506.    YSIZE( TTYInfo ) = (int) wVertSize ;
  507.    YSCROLL( TTYInfo ) = max( 0, (MAXROWS * YCHAR( TTYInfo )) -
  508.                                YSIZE( TTYInfo ) ) ;
  509.    nScrollAmt = min( YSCROLL( TTYInfo ), YOFFSET( TTYInfo ) ) -
  510.                      YOFFSET( TTYInfo ) ;
  511.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  512.  
  513.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  514.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), FALSE ) ;
  515.    SetScrollRange( hWnd, SB_VERT, 0, YSCROLL( TTYInfo ), TRUE ) ;
  516.  
  517.    XSIZE( TTYInfo ) = (int) wHorzSize ;
  518.    XSCROLL( TTYInfo ) = max( 0, (MAXCOLS * XCHAR( TTYInfo )) -
  519.                                 XSIZE( TTYInfo ) ) ;
  520.    nScrollAmt = min( XSCROLL( TTYInfo ), XOFFSET( TTYInfo )) -
  521.                      XOFFSET( TTYInfo ) ;
  522.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  523.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  524.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), FALSE ) ;
  525.    SetScrollRange( hWnd, SB_HORZ, 0, XSCROLL( TTYInfo ), TRUE ) ;
  526.  
  527.    InvalidateRect( hWnd, NULL, TRUE ) ;
  528.  
  529.    return ( TRUE ) ;
  530.  
  531. } // end of SizeTTY()
  532.  
  533. //---------------------------------------------------------------------------
  534. //  BOOL ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  535. //
  536. //  Description:
  537. //     Scrolls TTY window vertically.
  538. //
  539. //  Parameters:
  540. //     HWND hWnd
  541. //        handle to TTY window
  542. //
  543. //     WORD wScrollCmd
  544. //        type of scrolling we're doing
  545. //
  546. //     WORD wScrollPos
  547. //        scroll position
  548. //
  549. //---------------------------------------------------------------------------
  550.  
  551. BOOL ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  552. {
  553.    int        nScrollAmt ;
  554.  
  555.    if (NULL == TTYInfo)
  556.       return ( FALSE ) ;
  557.  
  558.    switch (wScrollCmd)
  559.    {
  560.       case SB_TOP:
  561.          nScrollAmt = -YOFFSET( TTYInfo ) ;
  562.          break ;
  563.  
  564.       case SB_BOTTOM:
  565.          nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  566.          break ;
  567.  
  568.       case SB_PAGEUP:
  569.          nScrollAmt = -YSIZE( TTYInfo ) ;
  570.          break ;
  571.  
  572.       case SB_PAGEDOWN:
  573.          nScrollAmt = YSIZE( TTYInfo ) ;
  574.          break ;
  575.  
  576.       case SB_LINEUP:
  577.          nScrollAmt = -YCHAR( TTYInfo ) ;
  578.          break ;
  579.  
  580.       case SB_LINEDOWN:
  581.          nScrollAmt = YCHAR( TTYInfo ) ;
  582.          break ;
  583.  
  584.       case SB_THUMBPOSITION:
  585.          nScrollAmt = wScrollPos - YOFFSET( TTYInfo ) ;
  586.          break ;
  587.  
  588.       default:
  589.          return ( FALSE ) ;
  590.    }
  591.    if ((YOFFSET( TTYInfo ) + nScrollAmt) > YSCROLL( TTYInfo ))
  592.       nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  593.    if ((YOFFSET( TTYInfo ) + nScrollAmt) < 0)
  594.       nScrollAmt = -YOFFSET( TTYInfo ) ;
  595.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  596.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  597.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), TRUE ) ;
  598.  
  599.    return ( TRUE ) ;
  600.  
  601. } // end of ScrollTTYVert()
  602.  
  603. //---------------------------------------------------------------------------
  604. //  BOOL ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  605. //
  606. //  Description:
  607. //     Scrolls TTY window horizontally.
  608. //
  609. //  Parameters:
  610. //     HWND hWnd
  611. //        handle to TTY window
  612. //
  613. //     WORD wScrollCmd
  614. //        type of scrolling we're doing
  615. //
  616. //     WORD wScrollPos
  617. //        scroll position
  618. //
  619. //---------------------------------------------------------------------------
  620.  
  621. BOOL ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  622. {
  623.    int        nScrollAmt ;
  624.  
  625.    if (NULL == TTYInfo)
  626.       return ( FALSE ) ;
  627.  
  628.    switch (wScrollCmd)
  629.    {
  630.       case SB_TOP:
  631.          nScrollAmt = -XOFFSET( TTYInfo ) ;
  632.          break ;
  633.  
  634.       case SB_BOTTOM:
  635.          nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  636.          break ;
  637.  
  638.       case SB_PAGEUP:
  639.          nScrollAmt = -XSIZE( TTYInfo ) ;
  640.          break ;
  641.  
  642.       case SB_PAGEDOWN:
  643.          nScrollAmt = XSIZE( TTYInfo ) ;
  644.          break ;
  645.  
  646.       case SB_LINEUP:
  647.          nScrollAmt = -XCHAR( TTYInfo ) ;
  648.          break ;
  649.  
  650.       case SB_LINEDOWN:
  651.          nScrollAmt = XCHAR( TTYInfo ) ;
  652.          break ;
  653.  
  654.       case SB_THUMBPOSITION:
  655.          nScrollAmt = wScrollPos - XOFFSET( TTYInfo ) ;
  656.          break ;
  657.  
  658.       default:
  659.          return ( FALSE ) ;
  660.    }
  661.    if ((XOFFSET( TTYInfo ) + nScrollAmt) > XSCROLL( TTYInfo ))
  662.       nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  663.    if ((XOFFSET( TTYInfo ) + nScrollAmt) < 0)
  664.       nScrollAmt = -XOFFSET( TTYInfo ) ;
  665.    ScrollWindow( hWnd, -nScrollAmt, 0, NULL, NULL ) ;
  666.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  667.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), TRUE ) ;
  668.  
  669.    return ( TRUE ) ;
  670.  
  671. } // end of ScrollTTYHorz()
  672.  
  673. //---------------------------------------------------------------------------
  674. //  BOOL SetTTYFocus( HWND hWnd )
  675. //
  676. //  Description:
  677. //     Sets the focus to the TTY window also creates caret.
  678. //
  679. //  Parameters:
  680. //     HWND hWnd
  681. //        handle to TTY window
  682. //
  683. //---------------------------------------------------------------------------
  684.  
  685. BOOL SetTTYFocus( HWND hWnd )
  686. {
  687. if (NULL == TTYInfo)
  688.     return ( FALSE ) ;
  689.  
  690.  if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_SHOW))
  691.  {
  692.       CreateCaret( hWnd, NULL, XCHAR( TTYInfo ), YCHAR( TTYInfo ) ) ;
  693.       ShowCaret( hWnd ) ;
  694.       CURSORSTATE( TTYInfo ) = CS_SHOW ;
  695.  }
  696.    MoveTTYCursor( hWnd ) ;
  697.    return ( TRUE ) ;
  698.  
  699. } // end of SetTTYFocus()
  700.  
  701. //---------------------------------------------------------------------------
  702. //  BOOL KillTTYFocus( HWND hWnd )
  703. //
  704. //  Description:
  705. //     Kills TTY focus and destroys the caret.
  706. //
  707. //  Parameters:
  708. //     HWND hWnd
  709. //        handle to TTY window
  710. //
  711. //---------------------------------------------------------------------------
  712.  
  713. BOOL KillTTYFocus( HWND hWnd )
  714. {
  715.    if (NULL == TTYInfo)
  716.       return ( FALSE ) ;
  717.  
  718.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_HIDE))
  719.    {
  720.       HideCaret( hWnd ) ;
  721.       DestroyCaret() ;
  722.       CURSORSTATE( TTYInfo ) = CS_HIDE ;
  723.    }
  724.    return ( TRUE ) ;
  725.  
  726. } // end of KillTTYFocus()
  727.  
  728. //---------------------------------------------------------------------------
  729. //  BOOL MoveTTYCursor( HWND hWnd )
  730. //
  731. //  Description:
  732. //     Moves caret to current position.
  733. //
  734. //  Parameters:
  735. //     HWND hWnd
  736. //        handle to TTY window
  737. //
  738. //---------------------------------------------------------------------------
  739.  
  740. BOOL MoveTTYCursor( HWND hWnd )
  741. {
  742.    if (NULL == TTYInfo)
  743.       return ( FALSE ) ;
  744.  
  745.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) & CS_SHOW))
  746.       SetCaretPos( (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  747.                    XOFFSET( TTYInfo ),
  748.                    (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  749.                    YOFFSET( TTYInfo ) ) ;
  750.  
  751.    return ( TRUE ) ;
  752.  
  753. } // end of MoveTTYCursor()
  754.  
  755.  
  756. //---------------------------------------------------------------------------
  757. //  BOOL ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  758. //
  759. //  Description:
  760. //     This simply writes a character to the port and echos it
  761. //     to the TTY screen if fLocalEcho is set.  Some minor
  762. //     keyboard mapping could be performed here.
  763. //
  764. //  Parameters:
  765. //     HWND hWnd
  766. //        handle to TTY window
  767. //
  768. //     BYTE bOut
  769. //        byte from keyboard
  770. //
  771. //---------------------------------------------------------------------------
  772.  
  773. BOOL ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  774. {
  775.    if (NULL == TTYInfo)
  776.       return ( FALSE ) ;
  777.  
  778.    if (!CONNECTED( TTYInfo ))
  779.       return ( FALSE ) ;
  780.  
  781.    WriteCommByte( hWnd, bOut ) ;
  782.    if (LOCALECHO( TTYInfo ))
  783.       WriteTTYBlock( hWnd, &bOut, 1 ) ;
  784.  
  785.    return ( TRUE ) ;
  786.  
  787. } // end of ProcessTTYCharacter()
  788.  
  789.  
  790. //********************************************************************
  791. //
  792. //  CMyPowerTelnet Class Definition
  793. //
  794. //********************************************************************
  795.  
  796. CMyPowerTelnet::CMyPowerTelnet(HINSTANCE hInstance) : CPowerTelnet(hInstance)
  797.     {
  798.     }
  799.     
  800. CMyPowerTelnet::~CMyPowerTelnet()
  801.     {
  802.     }
  803.  
  804. void CMyPowerTelnet::ConnectEvent(
  805.     LPCSTR    RemoteDotAddr, /* remote host connected to in dot notation */
  806.     WORD      RemotePort,/* remote port connected to */
  807.     LPCSTR    LocalDotAddr, /* local host address in dot notation */
  808.     WORD      LocalPort, /* local port */
  809.     LPCSTR    LocalName  /* name of default local host */
  810.     )
  811. {
  812.     HMENU hMenu;
  813.     hMenu = GetMenu( hWnd ) ;
  814.     EnableMenuItem( hMenu, IDM_DISCONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  815.     EnableMenuItem( hMenu, IDM_CONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  816.     CONNECTED( TTYInfo ) = TRUE;
  817.     SetTTYFocus(hWnd);
  818. }
  819.     
  820. void CMyPowerTelnet::TelnetRecvEvent(
  821.     LPBYTE    Data,  /* data from remote source */ 
  822.     UINT    Cnt        /* byte count for RecvData */
  823.     )
  824. {
  825.    if (!Data)       
  826.        {
  827.         HMENU hMenu;
  828.            KillTTYFocus( hWnd ) ;
  829.            CONNECTED( TTYInfo )     = FALSE ;
  830.         hMenu = GetMenu( hWnd ) ;
  831.         EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  832.         EnableMenuItem( hMenu, IDM_DISCONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  833.         }
  834.     else
  835.         WriteTTYBlock( hWnd, (LPBYTE)Data, (int) Cnt );
  836. }    
  837.  
  838. void CMyPowerTelnet::TelnetCmdEvent(
  839.     BYTE      Cmd,       /* TELNET command (WILL, WONT, DO, DONT...) */ 
  840.     BYTE      Option,    /* TELNET option number */ 
  841.     LPBYTE    SubOption, /* pointer to sub-option string */ 
  842.     UINT      SubOptionCnt        /* byte count for SubOption */
  843.     )
  844. {
  845.    switch (Cmd)
  846.        {
  847.        case WILL_CMD:
  848.            if(( Option == 3) || ( Option == 1))
  849.                    SendCmd(DO_CMD,Option,NULL,0,0);
  850.            else
  851.                    SendCmd(DONT_CMD,Option,NULL,0,0);
  852.            break;
  853.        case WONT_CMD:
  854.            break;
  855.        case DO_CMD:
  856.                if (Option==TERMTYPE_OPTION)
  857.                    // negotiate term type
  858.                    SendCmd(WILL_CMD,Option,NULL,0,0);
  859.                else
  860.                    SendCmd(WONT_CMD,Option,NULL,0,0);
  861.            break;
  862.        case DONT_CMD:
  863.                SendCmd(WONT_CMD,Option,NULL,0,0);
  864.            break;
  865.        case SB_CMD:
  866.            if( SubOptionCnt && SubOption) 
  867.                    SendCmd(SB_CMD,Option,(LPBYTE)"\000network",8,0);
  868.            else
  869.                   SendCmd(WONT_CMD,Option,NULL,0,0);
  870.            break;
  871.        default:
  872.            break; 
  873.        }           
  874. }    
  875.  
  876. void CMyPowerTelnet::ExceptionEvent(
  877.     PT_EXCEPTION ErrorCode,  /* spontaneous error notification */
  878.     LPCSTR    ErrorDesc  /* description of error */
  879.     )          
  880. {
  881.     MessageBox(NULL,ErrorDesc,"Exception Event Report",MB_OK);
  882. }
  883.                        
  884. //---------------------------------------------------------------------------
  885. //  BOOL FAR PASCAL __export ConnectDlgProc( HWND hDlg, UINT uMsg,
  886. //                                WPARAM wParam, LPARAM lParam )
  887. //
  888. //  Description:
  889. //    Creates a connect box for the connection.
  890. //
  891. //  Parameters:
  892. //     Same as standard dialog procedures.
  893. //
  894. //---------------------------------------------------------------------------
  895. //////////////////////////////////////////////////////////////
  896.  
  897. BOOL CALLBACK ConnectDlgProc( HWND hDlg, UINT uMsg,
  898.                                 WPARAM wParam, LPARAM lParam )
  899. {  
  900.    switch (uMsg)
  901.    {
  902.     case WM_INITDIALOG:
  903.          SetDlgItemText( hDlg, IDC_HOST, szHost ) ;
  904.          SetDlgItemText( hDlg, IDC_PORT, szPort ) ;
  905.     break;
  906.       
  907.     case WM_COMMAND:
  908.       if ((WORD) wParam == IDD_OK)
  909.        {
  910.            GetDlgItemText( hDlg, IDC_HOST, szHost, sizeof( szHost ) ) ;
  911.            Port = (WORD)GetDlgItemInt( hDlg, IDC_PORT, &TransOk, FALSE); 
  912.         EndDialog( hDlg, TRUE ) ;
  913.         return ( TRUE ) ;
  914.        }
  915.        
  916.       if ((WORD) wParam == IDD_CANCEL)
  917.        {
  918.         EndDialog( hDlg, FALSE) ;
  919.         return (FALSE) ;
  920.        }
  921.        
  922.     break;
  923.    }
  924.  return ( FALSE ) ;
  925. } // end of ConnectDlgProc()
  926.  
  927.  
  928.  
  929. BOOL OpenConnection( HWND hWnd )
  930. {
  931.  
  932. HCURSOR    hOldCursor, hWaitCursor ;
  933.  
  934. // show the hourglass cursor
  935. hWaitCursor = LoadCursor( NULL, IDC_WAIT ) ;
  936. hOldCursor = SetCursor( hWaitCursor ) ;
  937.  
  938.  
  939. if (GoModalDialogBoxParam( hInstance, MAKEINTRESOURCE( CONNECTDLGBOX ), hWnd,
  940.                        ConnectDlgProc, 0l))
  941.    {
  942.    
  943.    if (!MyPowerTelnet)
  944.        MyPowerTelnet=new CMyPowerTelnet(hInstance);
  945.        
  946.    MyPowerTelnet->hWnd=hWnd;
  947.  
  948.    MyPowerTelnet->Connect (
  949.         NULL,                 /* use license number assigned to you by Dart */ 
  950.         PT_DEBUG,        /* set to PT_DEBUG to get debugging information */ 
  951.         (LPCSTR) szHost,  /* use name or dot notation */ 
  952.         Port,                     /* port to connect to (usually 23 for TELNET) */ 
  953.         NULL,                     /* NULL or local dot address for multi-homed host */
  954.         0                        /* use any local port available */ 
  955.         );
  956.     }
  957.     
  958. return (TRUE);
  959. } // end of OpenConnection()
  960.  
  961. //---------------------------------------------------------------------------
  962. //  BOOL CloseConnection( HWND hWnd )
  963. //
  964. //  Description:
  965. //     Closes the connection to the port.  Resets the connect flag
  966. //     in the TTYINFO struct.
  967. //
  968. //  Parameters:
  969. //     HWND hWnd
  970. //        handle to TTY window
  971. //
  972. //---------------------------------------------------------------------------
  973.  
  974. BOOL CloseConnection( HWND hWnd )
  975. {
  976.    if (MyPowerTelnet)
  977.         MyPowerTelnet->Close(TRUE);    // do a hard close
  978.    return ( TRUE ) ;
  979.  
  980. } // end of CloseConnection()
  981.  
  982.  
  983. //---------------------------------------------------------------------------
  984. //  BOOL WriteCommByte( HWND hWnd, BYTE bByte )
  985. //
  986. //  Description:
  987. //     Writes a byte to the COM port specified in the associated
  988. //     TTY info structure.
  989. //
  990. //  Parameters:
  991. //     HWND hWnd
  992. //        handle to TTY window
  993. //
  994. //     BYTE bByte
  995. //        byte to write to port
  996. //
  997. //---------------------------------------------------------------------------
  998.  
  999. BOOL WriteCommByte( HWND hWnd, BYTE bByte )
  1000. {
  1001.    if (NULL == TTYInfo)
  1002.       return ( FALSE ) ;
  1003.  
  1004.    //WriteComm( COMDEV( TTYInfo ), (LPSTR) &bByte, 1 ) ;
  1005.    if (MyPowerTelnet)
  1006.            MyPowerTelnet->Send(&bByte, 1, FALSE, 0);
  1007.  
  1008.    return ( TRUE ) ;
  1009.  
  1010. } // end of WriteCommByte()
  1011.  
  1012. //---------------------------------------------------------------------------
  1013. //  BOOL WriteTTYBlock( HWND hWnd, LPSTR lpBlock, int nLength )
  1014. //
  1015. //  Description:
  1016. //     Writes block to TTY screen.  Nothing fancy - just
  1017. //     straight TTY.
  1018. //
  1019. //  Parameters:
  1020. //     HWND hWnd
  1021. //        handle to TTY window
  1022. //
  1023. //     LPSTR lpBlock
  1024. //        far pointer to block of data
  1025. //
  1026. //     int nLength
  1027. //        length of block
  1028. //
  1029. //---------------------------------------------------------------------------
  1030.  
  1031. BOOL WriteTTYBlock( HWND hWnd, LPBYTE lpBlock, int nLength )
  1032. {
  1033.    int        i ;
  1034.    RECT       rect ;
  1035.  
  1036.    if (NULL == TTYInfo)
  1037.       return ( FALSE ) ;
  1038.  
  1039.    for (i = 0 ; i < nLength; i++)
  1040.    {
  1041.       switch (lpBlock[ i ])
  1042.       {
  1043.            case 0:
  1044.              // do not print NULLs
  1045.             break;
  1046.  
  1047.          case ASCII_BEL:
  1048.             // Bell
  1049.             MessageBeep( 0 ) ;
  1050.             break ;
  1051.  
  1052.          case ASCII_BS:
  1053.             // Backspace
  1054.             if (COLUMN( TTYInfo ) > 0)
  1055.                COLUMN( TTYInfo ) -- ;
  1056.             MoveTTYCursor( hWnd ) ;
  1057.             break ;
  1058.  
  1059.          case ASCII_CR:
  1060.             // Carriage return
  1061.             COLUMN( TTYInfo ) = 0 ;
  1062.             MoveTTYCursor( hWnd ) ;
  1063.             if (!NEWLINE( TTYInfo ))
  1064.                break;
  1065.  
  1066.             // fall through
  1067.  
  1068.          case ASCII_LF:
  1069.             // Line feed
  1070.             if (ROW( TTYInfo )++ == MAXROWS - 1)
  1071.             {
  1072.                memmove( (SCREEN( TTYInfo )),
  1073.                           (SCREEN( TTYInfo ) + MAXCOLS),
  1074.                           (MAXROWS - 1) * MAXCOLS ) ;
  1075.                memset( (SCREEN( TTYInfo ) + (MAXROWS - 1) * MAXCOLS),
  1076.                          ' ', MAXCOLS ) ;
  1077.                InvalidateRect( hWnd, NULL, FALSE ) ;
  1078.                ROW( TTYInfo )-- ;
  1079.             }
  1080.             MoveTTYCursor( hWnd ) ;
  1081.             break ;
  1082.  
  1083.          default:
  1084.             *(SCREEN( TTYInfo ) + ROW( TTYInfo ) * MAXCOLS +
  1085.                 COLUMN( TTYInfo )) = lpBlock[ i ] ;
  1086.             rect.left = (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  1087.                         XOFFSET( TTYInfo ) ;
  1088.             rect.right = rect.left + XCHAR( TTYInfo ) ;
  1089.             rect.top = (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  1090.                        YOFFSET( TTYInfo ) ;
  1091.             rect.bottom = rect.top + YCHAR( TTYInfo ) ;
  1092.             InvalidateRect( hWnd, &rect, FALSE ) ;
  1093.  
  1094.             // Line wrap
  1095.             if (COLUMN( TTYInfo ) < MAXCOLS - 1)
  1096.                COLUMN( TTYInfo )++ ;
  1097.             else if (AUTOWRAP( TTYInfo ))
  1098.                WriteTTYBlock( hWnd, (LPBYTE)"\r\n", 2 ) ;
  1099.             break;
  1100.       }
  1101.    }
  1102.    return ( TRUE ) ;
  1103.  
  1104. } // end of WriteTTYBlock()
  1105.  
  1106. //---------------------------------------------------------------------------
  1107. //  VOID GoModalDialogBoxParam( HINSTANCE hInstance,
  1108. //                                   LPCSTR lpszTemplate, HWND hWnd,
  1109. //                                   DLGPROC lpDlgProc, LPARAM lParam )
  1110. //
  1111. //  Description:
  1112. //     It is a simple utility function that simply performs the
  1113. //     MPI and invokes the dialog box with a DWORD paramter.
  1114. //
  1115. //  Parameters:
  1116. //     similar to that of DialogBoxParam() with the exception
  1117. //     that the lpDlgProc is not a procedure instance
  1118. //
  1119. //---------------------------------------------------------------------------
  1120.  
  1121. BOOL GoModalDialogBoxParam( HINSTANCE hInstance, LPCSTR lpszTemplate,
  1122.                              HWND hWnd, DLGPROC lpDlgProc, LPARAM lParam )
  1123. {   
  1124.     BOOL DlgResp  = DialogBoxParam( hInstance, lpszTemplate, hWnd, lpDlgProc, lParam ) ;
  1125.    return (DlgResp);
  1126. } // end of GoModalDialogBoxParam()
  1127.  
  1128. //---------------------------------------------------------------------------
  1129. //  BOOL FAR PASCAL __export AboutDlgProc( HWND hDlg, UINT uMsg,
  1130. //                                WPARAM wParam, LPARAM lParam )
  1131. //
  1132. //  Description:
  1133. //     Simulates the Windows System Dialog Box.
  1134. //
  1135. //  Parameters:
  1136. //     Same as standard dialog procedures.
  1137. //
  1138. //---------------------------------------------------------------------------
  1139.  
  1140. BOOL CALLBACK AboutDlgProc( HWND hDlg, UINT uMsg,
  1141.                               WPARAM wParam, LPARAM lParam )
  1142. {
  1143.    switch (uMsg)
  1144.    {
  1145.       case WM_INITDIALOG:
  1146.       {
  1147.          char         szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ] ;
  1148.          DWORD        dwFreeMemory;
  1149.          WORD         wRevision, wVersion ;
  1150.  
  1151.          // sets up the version number for Windows
  1152.  
  1153.          wVersion = LOWORD( GetVersion() ) ;
  1154.          switch (HIBYTE( wVersion ))
  1155.          {
  1156.             case 10:
  1157.                wRevision = 1 ;
  1158.                break ;
  1159.  
  1160.             default:
  1161.                wRevision = 0 ;
  1162.                break;
  1163.          }
  1164.          wVersion &= 0xFF ;
  1165.  
  1166.          GetDlgItemText( hDlg, IDD_TITLELINE, szTemp, sizeof( szTemp ) ) ;
  1167.          wsprintf( szBuffer, szTemp, wVersion, wRevision ) ;
  1168.          SetDlgItemText( hDlg, IDD_TITLELINE, szBuffer ) ;
  1169.  
  1170.          // sets up version number for TTY
  1171.  
  1172.          GetDlgItemText( hDlg, IDD_VERSION, szTemp, sizeof( szTemp ) ) ;
  1173.          wsprintf( szBuffer, szTemp, VER_MAJOR, VER_MINOR, VER_BUILD ) ;
  1174.          SetDlgItemText( hDlg, IDD_VERSION, (LPSTR) szBuffer ) ;
  1175.  
  1176.          // get free memory information
  1177.  
  1178.          dwFreeMemory = GetFreeSpace( 0 ) / 1024L ;
  1179.          GetDlgItemText( hDlg, IDD_FREEMEM, szTemp, sizeof( szTemp ) ) ;
  1180.          wsprintf( szBuffer, szTemp, dwFreeMemory ) ;
  1181.          SetDlgItemText( hDlg, IDD_FREEMEM, (LPSTR) szBuffer ) ;
  1182.  
  1183.       }
  1184.       return ( TRUE ) ;
  1185.  
  1186.  
  1187.       case WM_COMMAND:
  1188.          if ((WORD) wParam == IDD_OK)
  1189.          {
  1190.             EndDialog( hDlg, TRUE ) ;
  1191.             return ( TRUE ) ;
  1192.          }
  1193.          break;
  1194.    }
  1195.    return ( FALSE ) ;
  1196.  
  1197. } // end of AboutDlgProc()
  1198.  
  1199.